'use strict';

/**
 * 🛠️ 通义千问消息监听脚本（生产版）v3.1
 * 功能：当用户提问或 AI 完成回复时，向后台发送 messageUpdate 事件
 * 特性：
 *   - 使用 class 前缀匹配（兼容 foldItem 等动态 class）
 *   - 监听 .tongyi-markdown 和 .rightArea 出现
 *   - 防止重复上报
 * 
 * @author 你
 * @version 3.1
 */

// ============================
// 🔧 配置项（使用 class 前缀，避免动态 class 干扰）
// ============================
const CONFIG = {
    // 👤 用户提问根容器 class 前缀
    USER_ITEM_PREFIX: '.questionItem--UrcRIuHd',

    // 🤖 AI 回答根容器 class 前缀
    AI_ITEM_PREFIX: '.answerItem--Fjp8fBsN',

    // 用户内容块
    USER_CONTENT_SELECTOR:'.bubble--OXh8Wwa1',

    // AI 内容块（Markdown 渲染区域）
    AI_CONTENT_SELECTOR: '.tongyi-markdown',

    // AI 完成标志（右侧操作区：点赞/点踩/复制）
    AI_COMPLETE_SELECTOR: '.rightArea--rL5UNOps',

    // 问答消息的容器
    USER_AI_SELECTOR:'.scrollWrapper--G2M0l9ZP',

    // // API配置
    // API_BASE_URL: 'http://localhost:5000',        // 后端API基础地址
    // API_ENDPOINT: '/api/report-message',          // 上报消息的后端API地址


    INPUT_SELECTOR: '.textareaWrap--d_4l80EV textarea', // 通义千问输入框的选择器（需根据实际页面调整）
    SUMMARY_PROMPT: `
        # 角色与核心任务
        你是一名专业的对话分析师，专门为解决临时对话的上下文长度限制问题服务。你的任务是将当前对话历史浓缩为一份精炼、自包含的摘要。**此摘要是后续对话的唯一历史依据**，其质量直接决定对话能否流畅延续。

        # 核心指令
        1.  **信息提取**：从已有对话中提取出**不可或缺**的核心信息。
        2.  **高度浓缩**：用最简洁的语言承载最大的信息量，确保摘要本身足够短小，为后续对话留出充足空间。
        3.  **独立可用**：确保这份摘要完成后，即使丢弃所有原始对话历史，仅凭此摘要也能让任何AI模型理解对话的全貌和进度，并能做出连贯的回应。

        # 摘要结构化输出
        请严格按照以下四个部分组织内容，确保其成为一个独立的对话状态快照：

        1.  **【对话核心脉络】**
            *   用1至2句话概括**我们正在讨论的核心问题是什么**，以及**目前进展到哪一步**。

        2.  **【已确认的关键事实与决策】**
            *   以条目式列出已**明确敲定的事实、方案、共识或数据**。这些是后续对话必须遵循的“既定事实”。

        3.  **【下一步计划与待办事项】**
            *   以条目式列出已明确的**后续行动、待解决的问题或开放性问题**。这是对话要继续推进的方向。

        4.  **【关键实体与概念列表】**
            *   集中列出对话中出现的、后续很可能被提及的**核心名词、项目名、关键数据等**。此列表作为快速参考词典。

        # 输出规则
        - **语言**：中文。
        - **风格**：绝对精炼，使用名词性短语和条目化表达，避免任何描述性、评价性或重复性的语言。
        - **格式**：严格使用上述标题，条目前使用短横线（-）。
    `, // 预设提示词
    PROMPT_DELAY: 1000 // 填入提示词后的延迟毫秒数
        
};








// ============================
// 📦 状态管理
// ============================
// let state = {
//     /**
//      * 当前已成功上报的消息总数
//      */
//     messageCount: 0,

//     /**
//      * 假设一个 后端传来值
//      */
//     historyCount: 10,


//     /**
//      * 防抖：避免高频触发
//      */

//     debounceTimer: null,

//     sessionId: null,
    

// };

let state = {
    messageCount: 0,
    historyCount: 0,
    debounceTimer: null,
    sessionId: null,



    // summaryTriggered: false, // 新增：摘要触发标志
    currentSummarySession: null // 新增：当前触发摘要的会话ID
};

/**
 * 获取会话ID（直接从URL参数获取）
 * @returns {string|null} 会话ID或null（如果不存在）
 */
function getSessionId() {
    const params = new URLSearchParams(window.location.search);
    return params.get('sessionId'); // 直接从URL获取sessionId参数
}

/**
 * 统计当前消息总数
 * @returns {number} 页面上的总消息数（用户消息 + AI消息）
 */
function countMessages() {
    // 分别统计用户消息和AI消息的数量
    const userMsgs = document.querySelectorAll(CONFIG.USER_ITEM_PREFIX).length;
    const aiMsgs = document.querySelectorAll(CONFIG.AI_ITEM_PREFIX).length;
    return userMsgs + aiMsgs; // 返回总和
}





/**
 * 触发摘要生成流程
 */
function triggerSummaryGeneration() {
    // 防重复触发
    // if (state.summaryTriggered) {
    //     console.log('🔁 摘要生成已触发，跳过重复操作');
    //     return;
    // }
    
    const inputElement = document.querySelector(CONFIG.INPUT_SELECTOR);
    
    if (!inputElement) {
        console.error('❌ 未找到输入框元素');
        return;
    }
    
    // 填入提示词
    inputElement.value = CONFIG.SUMMARY_PROMPT;
    inputElement.focus();
    
    // 触发输入事件（确保UI更新）
    inputElement.dispatchEvent(new Event('input', { bubbles: true }));
    
    // 显示用户提示
    showSummaryPrompt();
    
    // state.summaryTriggered = true;
    console.log('✅ 已触发摘要生成流程');
}

/**
 * 显示摘要生成提示
 */
function showSummaryPrompt() {
    // 方式1：使用浏览器原生提示（简单但可能被拦截）
    // alert('🎯 对话长度已触发摘要生成条件，提示词已自动填入，请确认发送。');
    
    // 方式2：创建自定义提示浮层（推荐）
    createCustomPromptUI();
}




/**
 * 创建自定义提示UI
 */
function createCustomPromptUI() {
    // 移除已存在的提示
    const existingPrompt = document.getElementById('summary-helper-prompt');
    if (existingPrompt) {
        existingPrompt.remove();
    }
    
    // 创建提示元素
    const promptElement = document.createElement('div');
    promptElement.id = 'summary-helper-prompt';
    promptElement.innerHTML = `
        <div style="
            position: fixed;
            top: 20px;
            right: 20px;
            background: #e3f2fd;
            border: 1px solid #2196f3;
            border-radius: 8px;
            padding: 12px;
            max-width: 300px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
            z-index: 10000;
            font-family: system-ui;
        ">
            <div style="font-weight: bold; margin-bottom: 8px; color: #1565c0;">
                🎯 摘要生成提示
            </div>
            <div style="font-size: 14px; color: #333; margin-bottom: 10px;">
                检测到对话长度适合生成摘要，提示词已自动填入输入框。
            </div>
            <button id="summary-helper-dismiss" style="
                background: #2196f3;
                color: white;
                border: none;
                padding: 6px 12px;
                border-radius: 4px;
                cursor: pointer;
                font-size: 12px;
            ">知道了</button>
        </div>
    `;
    
    document.body.appendChild(promptElement);
    
    // 添加关闭事件
    document.getElementById('summary-helper-dismiss').onclick = function() {
        promptElement.remove();
    };
    
    // 5秒后自动消失
    setTimeout(() => {
        if (promptElement.parentNode) {
            promptElement.remove();
        }
    }, 5000);
}


/**
 * 上报新消息到 background
 * @param {string} role - 'user' 或 'assistant'
 * @param {string} content - 消息内容
 */

function reportMessage(new_messages,message_type){

    const current_total = state.messageCount

    chrome.runtime.sendMessage({
    type: 'reportMessages',
    sessionId: state.sessionId,
    current_total: current_total,
    message_type: message_type,
    new_messages: new_messages
    }, (response) => {
        if (response?.status === 'received') {
            console.log(`📤 消息已上报，后端返回:`, response);
            
            const { sessionId, token_count, temp_token_count, summary_required, total_uploaded } = response;
            
            // 更新本地状态
            state.messageCount = total_uploaded;
            
            // 🔥 新增：检查摘要触发条件
            if (summary_required) {
                console.log('🔔 后端请求生成摘要');
                // 短暂延迟确保DOM稳定
                setTimeout(() => {
                    triggerSummaryGeneration();
                }, CONFIG.PROMPT_DELAY);
            }
            
            console.log(`✅ 会话: ${sessionId}, 总消耗 Token: ${token_count}, 本轮token: ${temp_token_count}`);
        }
    });


}


/**
 * 获取网页上所有消息（用户消息和AI消息）
 * @returns {Array} 消息对象数组，格式: {role: string, date: string, content: string}
 */



function getAllMessages() {
    const messages = [];
    
    // 直接全局查询所有消息项（最简洁高效的方法）
    const messageUnits = document.querySelectorAll(
        `${CONFIG.USER_ITEM_PREFIX}, ${CONFIG.AI_ITEM_PREFIX}`
    );
    
    messageUnits.forEach(unit => {
        // 判断消息类型并提取内容
        const isUserMessage = unit.matches(CONFIG.USER_ITEM_PREFIX);
        const contentSelector = isUserMessage ? CONFIG.USER_CONTENT_SELECTOR : CONFIG.AI_CONTENT_SELECTOR;
        
        const contentElement = unit.querySelector(contentSelector);
        if (contentElement) {
            // ✅ 关键修改：过滤掉style标签内容
            const cleanedContent = removeStyleTags(contentElement);
            messages.push({
                role: isUserMessage ? 'user' : 'assistant',
                date: new Date().toISOString(),
                content: cleanedContent

            });
        }
    });
    
    console.log(`✅ 获取 ${messages.length} 条消息`);
    return messages;
}

// ✅ 新增函数：移除所有<style>标签内容
function removeStyleTags(element) {
    // 克隆元素避免修改原始DOM
    const clonedElement = element.cloneNode(true);
    
    // 移除所有<style>标签
    const styleTags = clonedElement.querySelectorAll('style');
    styleTags.forEach(tag => tag.remove());
    
    // 返回清理后的文本内容
    return clonedElement.textContent.trim();
}



// ============================
// 🔭 监听单个“对话根节点”的完成状态
// ============================
function observeRootItem(rootElement,type) {
    /**
     * 监听一个根节点（用户或 AI），直到其内容完成，并上报消息
     * @param {HTMLElement} rootElement - .answerItem--xxx 或 .questionItem--xxx
     */

    // 1. 用户提问：插入即完成
    if (type === 'user') {

        // isUserMessage = true;
       // 清除之前的定时器
        if (state.debounceTimer) {
            clearTimeout(state.debounceTimer);
        }


        state.debounceTimer = setTimeout(() => {
            const contentElement = rootElement.querySelector(CONFIG.USER_CONTENT_SELECTOR);
            if (contentElement) {
                const cleanedContent = removeStyleTags(contentElement);
                const message = [{
                    role: 'user',
                    date: new Date().toISOString(),
                    content: cleanedContent
                }];
                
                state.messageCount++;
                console.log('发送一条user消息：', cleanedContent.substring(0, 10));    
                console.log('消息计数：state.messageCount = ', state.messageCount, Date.now());
                
                // 直接上报单条用户消息
                reportMessage(message, 'add');
            }
            
            // 重置定时器引用
            state.debounceTimer = null;
        }, 1000);

    }




    // 2. AI 回答：需等待内容和操作区出现
    // 这里有问题  消息上报多次
    if (type === 'assistant') {
        const observer = new MutationObserver(() => {
            const aiContent = rootElement.querySelector(CONFIG.AI_CONTENT_SELECTOR);
            const rightArea = rootElement.querySelector(CONFIG.AI_COMPLETE_SELECTOR);
            
            if (aiContent && rightArea) {
                const cleanedContent = removeStyleTags(aiContent);
                const message = [{
                    role: 'assistant',
                    date: new Date().toISOString(),
                    content: cleanedContent
                }];
                
                state.messageCount++;
                console.log('发送一条assistant消息：', cleanedContent.substring(0, 10));
                console.log('消息计数：state.messageCount = ', state.messageCount);
                
                // 上报单条AI消息
                reportMessage(message, 'add');
                observer.disconnect(); // 停止监听
            }
        });

        // 监听子树变化
        observer.observe(rootElement, {
            childList: true,
            subtree: true
        });

        // 添加超时清理
        setTimeout(() => observer.disconnect(), 200000);
    }
    


}

function setupMutationObserver() {

    let isWindowLoaded = false;        // 标记 onload 是否已完成


    // 当页面刷新 重新获取页面所有聊天消息 作为权威数据
    window.addEventListener('load', function() {
        // isWindowLoaded = true;
        console.log('页面所有资源已加载完成！');
 

        // ✅ 关键修复：100ms 延迟确保渲染完成
        setTimeout(() => {

            state.sessionId = getSessionId();
            
            state.messageCount = countMessages();

            console.log('目前消息总数是：', state.messageCount);

            // 获取所有消息
            reportMessage(getAllMessages(),'history');

            isWindowLoaded = true;
        }, 500); // 100ms 延迟是黄金标准
    });



    // // fetchHistoryCount();
    const observer = new MutationObserver(() => {

        // 获取存放消息控件的容器
        const target = document.querySelector(CONFIG.USER_AI_SELECTOR);

        // 获取当前页面的sessionId，因为却换聊天并不会触发页面刷新
        // 所以在这里获取 sessionId
        state.sessionId = getSessionId();
 

        
        if (target && state.sessionId && isWindowLoaded) {


            // 🔥 立即补报已有消息
            // checkExistingMessages(target);
            startObserver(target);

            observer.disconnect(); // 停止监听 body
        }
    });

    // 开始监听 body 的子节点变化
    observer.observe(document.body, {
        childList: true,
        subtree: true
    });

    console.log('🟢 已开始监听 body，等待目标容器插入...');
}

// ✅ 单独提取出 observer 启动逻辑
function startObserver(target) {

    const observer = new MutationObserver((mutations) => {

        
        for (const mutation of mutations) {
            if (mutation.type !== 'childList') continue;

            const addedElements = Array.from(mutation.addedNodes)
                .filter(node => node.nodeType === Node.ELEMENT_NODE);


            for (const el of addedElements) {
                const userContent = el.matches(CONFIG.USER_ITEM_PREFIX);
                const aiContent = el.matches(CONFIG.AI_ITEM_PREFIX);

                if(userContent || aiContent){
                    let newSessionId = getSessionId();
                    if(state.sessionId !== newSessionId ){
                        sessionIdreload();
                        return;
                    }
                }


                if(userContent){
                    observeRootItem(el,'user');           
                }

                if(aiContent){

                   observeRootItem(el,'assistant');
                }

                
            
            }
        }
    });

    // ✅ 开始监听
    observer.observe(target, {
        childList: true,
        subtree: true
    });

    console.log('🟢 MutationObserver 已绑定，开始监控变化');

}

//======================
//刷新页面的方法  如果sessionId不同就刷新页面
//=======================
function sessionIdreload(){

    console.warn('会话已变更，即将刷新页面', {
        原sessionId: state.sessionId,
        当前sessionId: getSessionId()
    });
    // 🔁 主动刷新页面
    window.location.reload();
}



// ============================
// 🚀 初始化入口
// ============================
(function init() {
    console.log('🚀 通义千问消息监听脚本 v3.1 启动');

    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', setupMutationObserver);
    } else {
        setupMutationObserver();
    }
})();